{
 "cells": [
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-03T13:39:45.621729Z",
     "start_time": "2025-06-03T13:36:31.069963Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import jieba\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.linear_model import Perceptron\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "from tqdm import tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "from datetime import datetime\n",
    "\n",
    "\n",
    "# ------------------------------ 数据处理函数 ------------------------------\n",
    "def load_class_labels(class_path):\n",
    "    label_map = {}\n",
    "    if os.path.exists(class_path):\n",
    "        with open(class_path, 'r', encoding='utf-8') as f:\n",
    "            for idx, line in enumerate(f):\n",
    "                label_map[idx] = line.strip()\n",
    "    return label_map or {idx: f\"类别{idx}\" for idx in sorted(set(label_map.keys()))}\n",
    "\n",
    "\n",
    "def load_text_dataset(file_path):\n",
    "    texts, labels = [], []\n",
    "    with open(file_path, 'r', encoding='utf-8') as f:\n",
    "        for line in tqdm(f, desc=f\"加载 {file_path}\"):\n",
    "            line = line.strip()\n",
    "            if not line:\n",
    "                continue\n",
    "            parts = line.rsplit('\\t', 1)\n",
    "            if len(parts) == 2:\n",
    "                texts.append(parts[0])\n",
    "                labels.append(int(parts[1]))\n",
    "    return texts, labels\n",
    "\n",
    "\n",
    "def preprocess_texts(texts, stopwords):\n",
    "    processed = []\n",
    "    for text in tqdm(texts, desc=\"文本预处理\"):\n",
    "        words = jieba.cut(text, HMM=True)\n",
    "        filtered = [word for word in words if word not in stopwords and len(word) >= 2]\n",
    "        processed.append(' '.join(filtered))\n",
    "    return processed\n",
    "\n",
    "\n",
    "def load_imdb_data(data_path):\n",
    "    train_texts, train_labels = [], []\n",
    "    test_texts, test_labels = [], []\n",
    "\n",
    "    for label in ['pos', 'neg']:\n",
    "        for split in ['train', 'test']:\n",
    "            path = os.path.join(data_path, split, label)\n",
    "            for file_name in os.listdir(path):\n",
    "                if file_name.endswith('.txt'):\n",
    "                    with open(os.path.join(path, file_name), 'r', encoding='utf-8') as file:\n",
    "                        text = file.read()\n",
    "                        if split == 'train':\n",
    "                            train_texts.append(text)\n",
    "                            train_labels.append(1 if label == 'pos' else 0)\n",
    "                        else:\n",
    "                            test_texts.append(text)\n",
    "                            test_labels.append(1 if label == 'pos' else 0)\n",
    "    return train_texts, train_labels, test_texts, test_labels\n",
    "\n",
    "\n",
    "# ------------------------------ 模型训练函数 ------------------------------\n",
    "def run_perceptron(data, stopwords, label_map):\n",
    "    train_texts, train_labels, test_texts, test_labels = data\n",
    "    classes = list(label_map.values())\n",
    "\n",
    "    # 特征提取\n",
    "    vectorizer = TfidfVectorizer(max_features=10000, ngram_range=(1, 2))\n",
    "    X_train = vectorizer.fit_transform(preprocess_texts(train_texts, stopwords))\n",
    "    X_test = vectorizer.transform(preprocess_texts(test_texts, stopwords))\n",
    "\n",
    "    # 初始化感知机模型\n",
    "    model = Perceptron(max_iter=1000, random_state=42)\n",
    "\n",
    "    # 训练模型\n",
    "    start_time = datetime.now()\n",
    "    model.fit(X_train, train_labels)\n",
    "    train_time = (datetime.now() - start_time).total_seconds()\n",
    "\n",
    "    # 预测\n",
    "    train_pred = model.predict(X_train)\n",
    "    test_pred = model.predict(X_test)\n",
    "    train_acc = accuracy_score(train_labels, train_pred)\n",
    "    test_acc = accuracy_score(test_labels, test_pred)\n",
    "\n",
    "    # 输出结果\n",
    "    print(f\"\\n---------------- 感知机模型 ----------------\")\n",
    "    print(f\"训练集准确率: {train_acc:.4f}\")\n",
    "    print(f\"测试集准确率: {test_acc:.4f}\")\n",
    "    print(f\"训练时间: {train_time:.2f} 秒\")\n",
    "    print(\"分类报告:\\n\", classification_report(test_labels, test_pred, target_names=classes))\n",
    "\n",
    "    return {\n",
    "        \"model\": \"感知机模型\",\n",
    "        \"test_accuracy\": test_acc,\n",
    "        \"train_time\": train_time\n",
    "    }\n",
    "\n",
    "\n",
    "# ------------------------------ 主函数 ------------------------------\n",
    "def main():\n",
    "    print(f\"[{datetime.now()}] 文本分类实验开始...\")\n",
    "\n",
    "    # 新闻标题数据集\n",
    "    THUCNEWS_DATA_DIR = r\"D:\\mytest\\chenyajie\\shangji-3\\THUCNews-txt\"\n",
    "    THUCNEWS_CLASS_PATH = os.path.join(THUCNEWS_DATA_DIR, \"class.txt\")\n",
    "    stopwords = {\n",
    "        '的', '了', '在', '是', '我', '有', '和', '就', '不', '人', '都', '一',\n",
    "        '个', '上', '也', '很', '到', '说', '要', '去', '你', '会', '着', '没有'\n",
    "    }\n",
    "\n",
    "    # 加载新闻标题数据集\n",
    "    thucnews_train_texts, thucnews_train_labels = load_text_dataset(os.path.join(THUCNEWS_DATA_DIR, \"train.txt\"))\n",
    "    thucnews_test_texts, thucnews_test_labels = load_text_dataset(os.path.join(THUCNEWS_DATA_DIR, \"test.txt\"))\n",
    "    thucnews_label_map = load_class_labels(THUCNEWS_CLASS_PATH)\n",
    "    thucnews_data = (thucnews_train_texts, thucnews_train_labels, thucnews_test_texts, thucnews_test_labels)\n",
    "\n",
    "    # 输出新闻标题数据集信息\n",
    "    print(f\"新闻标题训练集样本数：{len(thucnews_train_texts)}\")\n",
    "    print(f\"新闻标题测试集样本数：{len(thucnews_test_texts)}\")\n",
    "\n",
    "    # 运行感知机模型 - 新闻标题数据集\n",
    "    thucnews_result = run_perceptron(thucnews_data, stopwords, thucnews_label_map)\n",
    "\n",
    "    # 电影评论数据集\n",
    "    IMDB_DATA_DIR = r\"D:\\mytest\\chenyajie\\shangji-3\\aclImdb\"\n",
    "\n",
    "    # 加载电影评论数据集\n",
    "    imdb_train_texts, imdb_train_labels, imdb_test_texts, imdb_test_labels = load_imdb_data(IMDB_DATA_DIR)\n",
    "    imdb_label_map = {0: 'neg', 1: 'pos'}\n",
    "    imdb_data = (imdb_train_texts, imdb_train_labels, imdb_test_texts, imdb_test_labels)\n",
    "\n",
    "    # 输出电影评论数据集信息\n",
    "    print(f\"电影评论训练集样本数：{len(imdb_train_texts)}\")\n",
    "    print(f\"电影评论测试集样本数：{len(imdb_test_texts)}\")\n",
    "\n",
    "    # 运行感知机模型 - 电影评论数据集\n",
    "    imdb_result = run_perceptron(imdb_data, stopwords, imdb_label_map)\n",
    "\n",
    "    # 将结果存储在一个列表中\n",
    "    results = [thucnews_result, imdb_result]\n",
    "    dataset_names = ['新闻标题数据集', '电影评论数据集']\n",
    "\n",
    "    # 这里可以添加保存结果到文件的代码，以便后续可视化使用\n",
    "    # 例如：np.savez('results.npz', results=results, dataset_names=dataset_names)\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ],
   "id": "7f2f97f0bed8a424",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2025-06-03 21:36:31.092724] 文本分类实验开始...\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "加载 D:\\mytest\\chenyajie\\shangji-3\\THUCNews-txt\\train.txt: 180000it [00:00, 677996.37it/s]\n",
      "加载 D:\\mytest\\chenyajie\\shangji-3\\THUCNews-txt\\test.txt: 10000it [00:00, 757313.30it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "新闻标题训练集样本数：180000\n",
      "新闻标题测试集样本数：10000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "文本预处理: 100%|██████████| 180000/180000 [00:18<00:00, 9897.42it/s] \n",
      "文本预处理: 100%|██████████| 10000/10000 [00:00<00:00, 12127.39it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------- 感知机模型 ----------------\n",
      "训练集准确率: 0.8910\n",
      "测试集准确率: 0.8417\n",
      "训练时间: 1.48 秒\n",
      "分类报告:\n",
      "                precision    recall  f1-score   support\n",
      "\n",
      "      finance       0.85      0.84      0.85      1000\n",
      "       realty       0.88      0.89      0.88      1000\n",
      "       stocks       0.76      0.78      0.77      1000\n",
      "    education       0.89      0.91      0.90      1000\n",
      "      science       0.81      0.80      0.80      1000\n",
      "      society       0.83      0.83      0.83      1000\n",
      "     politics       0.83      0.80      0.81      1000\n",
      "       sports       0.90      0.89      0.89      1000\n",
      "         game       0.86      0.86      0.86      1000\n",
      "entertainment       0.81      0.82      0.81      1000\n",
      "\n",
      "     accuracy                           0.84     10000\n",
      "    macro avg       0.84      0.84      0.84     10000\n",
      " weighted avg       0.84      0.84      0.84     10000\n",
      "\n",
      "电影评论训练集样本数：25000\n",
      "电影评论测试集样本数：25000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "文本预处理: 100%|██████████| 25000/25000 [01:11<00:00, 348.76it/s]\n",
      "文本预处理: 100%|██████████| 25000/25000 [01:05<00:00, 380.10it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------- 感知机模型 ----------------\n",
      "训练集准确率: 0.9904\n",
      "测试集准确率: 0.8535\n",
      "训练时间: 0.19 秒\n",
      "分类报告:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "         neg       0.86      0.84      0.85     12500\n",
      "         pos       0.85      0.86      0.86     12500\n",
      "\n",
      "    accuracy                           0.85     25000\n",
      "   macro avg       0.85      0.85      0.85     25000\n",
      "weighted avg       0.85      0.85      0.85     25000\n",
      "\n"
     ]
    }
   ],
   "execution_count": 21
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-06-03T13:43:10.454756Z",
     "start_time": "2025-06-03T13:43:09.801290Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from datetime import datetime\n",
    "import itertools\n",
    "from sklearn.metrics import confusion_matrix\n",
    "import numpy as np\n",
    "import itertools\n",
    "\n",
    "# ------------------------------ 可视化函数 ------------------------------\n",
    "def plot_results(results, dataset_names, confusion_matrices):\n",
    "    plt.figure(figsize=(15, 10))\n",
    "    plt.style.use('fivethirtyeight')\n",
    "\n",
    "    # 创建子图\n",
    "    fig, axs = plt.subplots(2, 2, figsize=(15, 10))\n",
    "\n",
    "    # 指定颜色\n",
    "    colors = ['#1f77b4', '#ff7f0e']\n",
    "\n",
    "    # 准确率对比\n",
    "    axs[0, 0].bar(dataset_names, [result['test_accuracy'] for result in results], color=colors)\n",
    "    axs[0, 0].set_title('测试集准确率对比')\n",
    "    axs[0, 0].set_ylabel('准确率')\n",
    "    axs[0, 0].set_ylim(0.7, 1.0)\n",
    "\n",
    "    # 添加准确率数值标签\n",
    "    for i, acc in enumerate([result['test_accuracy'] for result in results]):\n",
    "        axs[0, 0].text(i, acc, f'{acc:.4f}', ha='center', va='bottom')\n",
    "\n",
    "    # 训练时间对比\n",
    "    axs[0, 1].bar(dataset_names, [result['train_time'] for result in results], color=colors)\n",
    "    axs[0, 1].set_title('训练时间对比')\n",
    "    axs[0, 1].set_ylabel('训练时间（秒）')\n",
    "\n",
    "    # 添加训练时间数值标签\n",
    "    for i, time in enumerate([result['train_time'] for result in results]):\n",
    "        axs[0, 1].text(i, time, f'{time:.2f}s', ha='center', va='bottom')\n",
    "\n",
    "    # 混淆矩阵1\n",
    "    cm = confusion_matrices[0]\n",
    "    disp = plot_confusion_matrix(cm, classes=['类别0', '类别1'], ax=axs[1, 0], title=f\"{dataset_names[0]} 混淆矩阵\")\n",
    "    axs[1, 0].set_title(f\"{dataset_names[0]} 混淆矩阵\")\n",
    "\n",
    "    # 混淆矩阵2\n",
    "    cm = confusion_matrices[1]\n",
    "    disp = plot_confusion_matrix(cm, classes=['类别0', '类别1'], ax=axs[1, 1], title=f\"{dataset_names[1]} 混淆矩阵\")\n",
    "    axs[1, 1].set_title(f\"{dataset_names[1]} 混淆矩阵\")\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "def plot_confusion_matrix(cm, classes, ax, title='混淆矩阵'):\n",
    "    im = ax.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)\n",
    "    ax.figure.colorbar(im, ax=ax)\n",
    "    ax.set(xticks=np.arange(cm.shape[1]),\n",
    "           yticks=np.arange(cm.shape[0]),\n",
    "           xticklabels=classes, yticklabels=classes,\n",
    "           title=title,\n",
    "           ylabel='真实标签',\n",
    "           xlabel='预测标签')\n",
    "    plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\", rotation_mode=\"anchor\")\n",
    "\n",
    "    fmt = 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i in range(cm.shape[0]):\n",
    "        for j in range(cm.shape[1]):\n",
    "            ax.text(j, i, format(cm[i, j], fmt),\n",
    "                    ha=\"center\", va=\"center\",\n",
    "                    color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    ax.set_ylim(len(classes)-0.5, -0.5)\n",
    "    return ax\n",
    "\n",
    "\n",
    "# ------------------------------ 主函数 ------------------------------\n",
    "def main():\n",
    "    print(f\"[{datetime.now()}] 可视化结果展示...\")\n",
    "\n",
    "    # 示例结果数据（实际应用中，这里应从文件或数据库中加载）\n",
    "    results = [\n",
    "        {\"test_accuracy\": 0.85, \"train_time\": 12.34},\n",
    "        {\"test_accuracy\": 0.90, \"train_time\": 15.67}\n",
    "    ]\n",
    "    dataset_names = ['新闻标题数据集', '电影评论数据集']\n",
    "\n",
    "    # 混淆矩阵数据\n",
    "    confusion_matrices = [\n",
    "        np.array([[300, 50], [75, 375]]),\n",
    "        np.array([[350, 50], [60, 390]])\n",
    "    ]\n",
    "\n",
    "    # 绘制结果\n",
    "    plot_results(results, dataset_names, confusion_matrices)\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ],
   "id": "4dc169ad7b0076e2",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2025-06-03 21:43:09.825290] 可视化结果展示...\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1500x1000 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1500x1000 with 6 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 23
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
